<?php

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 * Description of dbconnection
 * @author Adelson
 */
class Dbconnection {

    private $host = DBHOST; //endereco host ou ip configuravel em config/config.php
    private $hostName = DBNAME; //nome do DB configuravel em config/config.php
    private $username = DBUSER; //usuario DB configuravel em config/config.php
    private $passwd = DBPASS; //senha DB configuravel em config/config.php
    public $conn; //propriedade que ira instacia o objeto PDO
    public $lastId; //propriedade que ira receber o ultimo id registrado no banco

    /* METODO CONSTRUTOR QUE IRA FAZER A CONEXAO
     * COM O BANCO DE DADOS 
     */

    public function __construct() {
        try {
            //cria a o objeto PDO para conexao com o banco de dados
            //mais informacoes acessar:http://php.net/manual/pt_BR/book.pdo.php
            $this->conn = new PDO("mysql:host=" . $this->host . ";dbname=" . $this->hostName, $this->username, $this->passwd);
            $this->conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        } catch (PDOException $ex) {
            die("Erro ao cone");
        }
    }

    /* METODO DESTRUITOR QUE IRA CORTAR A CONEXAO COM
     * BANCO DE DADOS
     * MAIS INFORMACOES: http://php.net/manual/en/pdo.connections.php
     */

    public function __destruct() {
        $this->conn = NULL;
    }

    /* METODO QUE APAGA OS REGISTRO DO BANCO DE DADOS
     * @PARAM STRING $tabela = TABELA QUE TERA SEUS DADOS ATUALIZADO
     * @FILTRO STRING $filtro = CONDICAO PARA DELETAR REGISTRO
     * RETURN JSON STRING
     */

    public function delete($tabela, $filtro = false) {
        try {
            if (!$filtro) {
                throw new PDOException("Error: filtro indefinido!!!");
            }

            /* TRECHO QUE MONTA O SQL PARA DELETAR REGISTRO */
            $sql = "DELETE FROM {$tabela} WHERE {$filtro}";
            $qr = $this->conn->prepare($sql); //prepara a instrucao do comando sql
            $exec = $qr->execute(); //executa a funcao sql insert
            if ($exec) {
                return json_encode(array("status" => true, "msg" => "Dados apagados com sucesso"));
            } else {
                return json_encode(array("status" => false, "msg" => "Erro ao executar esta tarefa - DELETE fn "));
            }
        } catch (Exception $ex) {
            return json_encode(array("status" => false, "msg" => "Erro ao executar esta tarefa - DELETE fn "));
        }
    }

    /* METODO RESPONSAVEL POR ATUALIZAR TABELAS DO BANCO DE DADOS
     * @PARAM STRING $tabela = TABELA QUE TERA SEUS DADOS ATUALIZADO
     * @PARAM ARRAY  $CAMPOS = ARRAY COM NOME DOS CAMPOS DA TABELA COMO 
     * INDICE E OS VALORES COMO O VALOR DO ARRAY
     * @PARAM $filtro = CONDICAO PARA FAZER A ATUALIZACAO
     * RETURN JSON STRING
     */

    public function update($tabela, $campos, $filtro = false) {
        try {
            if (!is_array($campos)) {
                throw new PDOException("Erro ao definir os campos");
            } else if ($filtro === false) {
                throw new PDOException("Intentifique o filtro para que possa ser executada esta tarefa");
            } else {
                /* ESTE TRECHO MONTA O COMANDO SQL PARA O UPDATE
                 * RECEBENDO COMO PARAMETRO @$tabela, $campos, @filtro
                 */
                $sql = "UPDATE {$tabela} SET ";
                $totalDados = count($campos);
                for ($i = 0; $i < $totalDados; $i++) {
                    $keys = array_keys($campos);
                    $value = array_values($campos);

                    $sql.= "{$keys[$i]} = '{$value[$i]}',";
                }
                $sql = substr_replace($sql, " ", -1, 1) . "WHERE {$filtro} ";
                $qr = $this->conn->prepare($sql); //prepara a instrucao do comando sql
                $exec = $qr->execute(); //executa a funcao sql insert
                if ($exec) {
                    return json_encode(array("status" => true, "msg" => "Dados Atualizado com sucesso"));
                } else {
                    return json_encode(array("status" => false, "msg" => "Erro ao atualizar dados no banco de dados - UPDATE fn"));
                }
            }
        } catch (PDOException $exc) {
            exit($exc->getMessage());
        }
    }

    /* METODO QUE GRAVA(INSERIR) DADOS NO BANCO DE DADOS
     * @PARAM STRING $tabela = TABELA QUE SERA INSERIDO OS DADOS
     * @PARAM ARRAY $campos = ARRAY ASSOCIATIVO COM NOME DOS CAMPOS DA TABELA COMO 
     * INDICE E OS VALORES COMO VALOR DO ARRAY
     * RETURN JSON STRING
     */

    public function Insert($tabela, $campos) {
        try {
            if (!is_array($campos)) {
                throw new PDOException("Erro na definicao dos campos!!!", 0);
            }
            /* Este trecho de codigo faz o comando insert do sql
             * recebendo como parametros @$tabela e @$campos
             */
            $sql = "INSERT INTO {$tabela} (";
            foreach (array_keys($campos) as $k) {
                $sql.= "{$k},";
            }
            $sql = substr_replace($sql, ")", -1, 1) . " VALUES (";
            foreach (array_values($campos) as $v) {
                $sql.="'{$v}',";
            }
            $sql = substr_replace($sql, ")", -1, 1);
            //prepara a instrucao do comando sql
            $qr = $this->conn->prepare($sql);
            //executa a funcao sql insert
            $exec = $qr->execute();
            if ($exec) {
                //se inserir o registro seta a propriedade do 
                //@lastId com o id do ultimo registro gravado
                $this->lastId = $this->conn->lastInsertId();
                return json_encode(array("status" => true, "msg" => "Dados gravados com sucesso"));
            } else {
                return json_encode(array("status" => false, "msg" => "Erro ao gravar dados no banco de dados"));
            }
        } catch (PDOException $exc) {
            exit($exc->getMessage());
        }
    }

    /* METODO SELECT PARA CONSULTA DE DADOS NO BANCO DE DADOS
     * @PARAM STRING $tabela = NOME DA TABELA A SER CONSULTADA
     * @PARAM MIXED ARRAY|STRING  $campos = NOME DO CAMPOS DA TABELA OU ARRAY ASSOCIATICVOS 
     * COM O NOME E O VALOR DOS CAMPOS EX: ARRAY("NOME"=>"foo");
     * @PARAM STRING $filtro = "CONDICAO DA CONSULTA"7
     * @PARAM BOOL $mode_obj = DEFINE O MODO QUE SERA O RETORNO DA CONSULTA
     * RETURN MIXED ARRAY|stdOBJECT
     */

    public function select($tabela, $campos = "*", $filtro = NULL, $mode_obj = false) {
        try {
            $fields = null;
            //verifica se a conexao foi aberta
            if (!$this->conn) {
                throw new PDOException("Erro ao conectar ao banco de dados", 0);
            }

            //verifica se os nomes do campos da tabela esta sendo setado como array ou string
            //e cria uma string no formato sql (foo,baz,....)
            if (!is_array($campos)) {
                $fields = $campos;
            } else {
                foreach (array_keys($campos) as $keys) {
                    $fields.="{$keys},";
                }
                $fields = substr_replace($fields, "", -1, 1);
            }

            //verifica se existe filtro caso nao existas na consulta
            $where = (!is_null($filtro)) ? " WHERE {$filtro} " : " WHERE 1=1 ";
            //cria a regra sql SELECT
            $sql = "SELECT {$fields} FROM {$tabela} {$where}";
            $qry = $this->conn->prepare($sql); //prepara a execucao da consulta
            $exec = $qry->execute(); //executa a consulta propriamente dito
            //verifica qual sera o modo do retorno select se o vai ser array assossiativo ou em stdObject
            if ($mode_obj) {
                $modoPDO = PDO::FETCH_OBJ;
            } else {
                $modoPDO = PDO::FETCH_ASSOC;
            }
            // se a consulta for executada 
            if ($exec) {
                return $qry->fetchAll($modoPDO);
            } else {
                throw new PDOException("Erro na execucao da consulta");
            }
        } catch (PDOException $exc) {
            exit($exc->getMessage());
        }
    }
    
    /*METODO QUE EXECUTA QUERY SQL
     * @PARAM STRING $query
     * @RETURN BOOL
     */
    public function executeTableSql($query){
        try {
            $exec = $this->conn->exec($query);
            return true;
        } catch (PDOException $exc) {
            exit($exc->getMessage());
        }
    }
    

}
